home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1995 June / MacFormat 25.iso / Shareware City / Developers / ICProgKit1.0 / Source / Libs / ICMappings.c next >
C/C++ Source or Header  |  1994-11-29  |  4KB  |  155 lines
  1. #include "ICAPI.h"
  2. #include "ICKeys.h"
  3.  
  4. #define    GETSHORT(p)        (short)((((unsigned char*)p)[0] << 8) | ((unsigned char*)p)[1])
  5.  
  6. static void UnpackCopyString (Ptr *p, StringPtr s)
  7. {
  8.     short    len;
  9.  
  10.     len = (**(char **)p) + 1;
  11.     BlockMoveData(*p, s, len);
  12.     *p = *p + len;
  13. }
  14.  
  15. static void PackCopyString (ConstStr255Param s, Ptr p, short *length)
  16. {
  17.     BlockMoveData(s, (Ptr)(p + *length), s[0] + 1);
  18.     *length += s[0] + 1;
  19. }
  20.  
  21.  
  22. // (* WARNING: Depends very much on the exact format of ICMapEntry! *)
  23. static OSErr UnpackEntry (Handle entries, long pos, ICMapEntry *entry, long *user_length)
  24. {    
  25.     OSErr    err = noErr;
  26.     Ptr        p, org;
  27.     long    maxsize;
  28.     
  29.     if ((entries == nil) || (*entries == nil) || 
  30.         (pos < 0) || (pos > GetHandleSize(entries) - 6))
  31.         return(paramErr);
  32.  
  33.     p = (*entries) + pos;
  34.     maxsize = GetHandleSize(entries);
  35.     org = p;
  36.     
  37.     BlockMoveData(p, entry, 6);
  38.     
  39.     if  ((entry->fixed_length != ICmap_fixed_length) || 
  40.          (entry->fixed_length > entry->total_length) ||
  41.          (entry->total_length > maxsize)) {
  42.         err = badExtResource;
  43.     } else {
  44.         BlockMoveData(p, entry, entry->fixed_length);
  45.         p = p + entry->fixed_length;
  46.         UnpackCopyString(&p, entry->extension);
  47.         UnpackCopyString(&p, entry->creator_app_name);
  48.         UnpackCopyString(&p, entry->post_app_name);
  49.         UnpackCopyString(&p, entry->MIME_type);
  50.         UnpackCopyString(&p, entry->entry_name);
  51.         *user_length = entry->total_length - (p - org);
  52.     }
  53.     return(err);
  54. }
  55.  
  56. static void PackEntry (ICMapEntry *entry, Ptr p, long user_length)
  57. {
  58.     entry->version = 0;
  59.     entry->fixed_length = (short)((long)&entry->extension - (long)entry);
  60.     entry->total_length = entry->fixed_length;
  61.     PackCopyString(entry->extension, p, &entry->total_length);
  62.     PackCopyString(entry->creator_app_name, p, &entry->total_length);
  63.     PackCopyString(entry->post_app_name, p, &entry->total_length);
  64.     PackCopyString(entry->MIME_type, p, &entry->total_length);
  65.     PackCopyString(entry->entry_name, p, &entry->total_length);
  66.     entry->total_length += user_length;
  67.     BlockMoveData(&entry, p, entry->fixed_length);
  68. }
  69.  
  70.  
  71. ICError ICMDeleteEntry (Handle entries, long pos)
  72. {
  73.     ICMapEntry    entry;
  74.     long        lerr;
  75.     long        user_length;
  76.     
  77.     lerr = UnpackEntry(entries, pos, &entry, &user_length);
  78.     if (lerr == noErr) {
  79.         lerr = Munger(entries, pos, nil, entry.total_length, (Ptr)-1, 0);
  80.         if (lerr >= 0)    lerr = noErr;
  81.     }
  82.     return(lerr);
  83. }
  84.  
  85.  
  86. ICError    ICMCountEntries (Handle entries, long *count)
  87. {
  88.     unsigned char    *p;
  89.     long            pos = 0, eLen = GetHandleSize(entries);
  90.     
  91.     p = (unsigned char *)(*entries);
  92.     *count = 0;
  93.     while (pos < eLen) {
  94.         pos += GETSHORT(p);
  95.         p += GETSHORT(p);
  96.         (*count)++;
  97.     }
  98.     return(noErr);
  99. }
  100.  
  101. ICError ICMGetEntry (Handle entries, long pos, ICMapEntry *entry)
  102. {
  103.     long    user_length;
  104.     
  105.     return(UnpackEntry(entries, pos, entry, &user_length));
  106. }
  107.  
  108. ICError    ICMGetIndEntry (Handle entries, long ndx,
  109.                         long *pos, ICMapEntry *entry)
  110. {
  111.     ICError    err;
  112.     unsigned char    *p;
  113.     long    i;
  114.     
  115.     p = (unsigned char *)(*entries);
  116.     *pos = 0;
  117.     while ((ndx > 1) && (*pos < GetHandleSize(entries))) {
  118.         *pos += GETSHORT(p);
  119.         p += GETSHORT(p);
  120.         ndx -= 1;
  121.     }
  122.     return(ICMGetEntry(entries, *pos, entry));
  123. }
  124.  
  125. ICError ICMAddEntry (Handle entries, ICMapEntry *entry)
  126. {
  127.     ICMapEntry    e;
  128.     
  129.     PackEntry(entry, (Ptr)&e, 0);
  130.     return(PtrAndHand(&e, entries, entry->total_length));
  131. }
  132.  
  133. ICError ICMSetEntry (Handle entries, long pos, ICMapEntry *entry)
  134. {
  135.     ICError        err;
  136.     ICMapEntry    e, oldentry;
  137.     long        user_length, source_length;
  138.     
  139.     err = UnpackEntry(entries, pos, &oldentry, &user_length);
  140.     if (err == noErr) {
  141.         PackEntry(entry, (Ptr)&e, user_length);
  142.         source_length = oldentry.total_length - user_length;
  143.         if (user_length < 8) {
  144.             // hack to remove alignment bytes from previous version
  145.             source_length = oldentry.total_length;
  146.             e.total_length = e.total_length - user_length;
  147.             user_length = 0;
  148.         }
  149.         err = Munger(entries, pos, nil, source_length, &e, e.total_length - user_length);
  150.         if (err >= 0)    err = noErr;
  151.     }
  152.     
  153.     return(err);
  154. }
  155.